home *** CD-ROM | disk | FTP | other *** search
/ IBM InfoROM for OS/2 Beta 1995 January / IBM InfoROM for OS2 Beta 1-1995.ISO / testcert / storage / function / dasd / ioctl / dasd.gra < prev    next >
Encoding:
Text File  |  1994-07-13  |  16.9 KB  |  398 lines

  1. ******************************************************************************
  2. **                       DASD.GRA DESCRIPTION FILE                          **
  3. ******************************************************************************
  4. **                          DASD FUNCTION CALLS                             **
  5. ******************************************************************************
  6. @IMPORT GLOBAL.GRA
  7. DASD_QLOCK $DLL=DDTDASD $FUNC=@query_lock$qr8Kwd_List
  8. ******************************************************************************
  9. DASD_OPEN                      $DLL=DDTDASD  \
  10.                                DEVICENAME=STRING  \ 
  11.                                $FUNC=@open_logical$qr8Kwd_List
  12. **
  13. ** THIS FUNCTION OPENS 1 PARTITION ON A PHYSICAL DRIVE.
  14. **
  15. **   NEEDED PARAMETERS:          DEVICENAME
  16. **
  17. **   RETURNS:                    add DRIVEHANDLE
  18. **
  19. ******************************************************************************
  20. DASD_CLOSE                     $DLL=DDTDASD  \
  21.                                DRIVEHANDLE=NUM  \
  22.                                $FUNC=@close_logical$qr8Kwd_List
  23. **
  24. ** THIS FUNCTION CLOSES 1 PARTITION ON A PHYSICAL DRIVE.
  25. **
  26. **   NEEDED PARAMETERS:          DRIVEHANDLE   : DRIVE HANDLE FOR DRIVE
  27. **
  28. **   RETURNS:                    del DRIVEHANDLE
  29. **
  30. ******************************************************************************
  31. LOCK_LOGICAL                   $DLL=DDTDASD  \
  32.                                DRIVEHANDLE=NUM  \
  33.                                $FUNC=@lock_logical$qr8Kwd_List
  34. **
  35. ** THIS FUNCTION LOCKS 1 PARTITION ON A PHYSICAL DRIVE. 
  36. **
  37. **   NEEDED PARAMETERS:          DRIVEHANDLE   : DRIVE HANDLE FOR DRIVE
  38. **
  39. **   RETURNS:                    NOTHING
  40. **
  41. ******************************************************************************
  42. UNLOCK_LOGICAL                 $DLL=DDTDASD  \
  43.                                DRIVEHANDLE=NUM  \
  44.                                $FUNC=@unlock_logical$qr8Kwd_List
  45. **
  46. ** THIS FUNCTION UNLOCKS 1 PARTITION ON A PHYSICAL DRIVE.
  47. **
  48. **   NEEDED PARAMETERS:          DRIVEHANDLE   : DRIVE HANDLE FOR DRIVE
  49. **
  50. **   RETURNS:                    NOTHING
  51. **
  52. ******************************************************************************
  53. GET_LOGICAL_PARAMS             $DLL=DDTDASD  \
  54.                                DRIVEHANDLE=NUM  \
  55.                                $FUNC=@get_logical_params$qr8Kwd_List
  56. **
  57. ** THIS FUNCTION GETS THE LOGICAL PARAMETERS OF 1 PARTITION ON A PHYSICAL
  58. ** DRIVE. 
  59. **
  60. **   NEEDED PARAMETERS:          DRIVEHANDLE   : DRIVE HANDLE FOR DRIVE
  61. **
  62. **   RETURNS:                    SECTORSIZE
  63. **                               CLUSTERSIZE 
  64. **                               FATCOUNT
  65. **                               ROOTCOUNT
  66. **                               SECTORCOUNT
  67. **                               FATSIZE
  68. **                               TRACKSIZE
  69. **                               HEADCOUNT
  70. **
  71. ******************************************************************************
  72. QMEDIA_SENSE                   $DLL=DDTDASD  \
  73.                                DRIVEHANDLE=NUM \
  74.                                $FUNC=@qmedia_sense$qr8Kwd_List
  75. **
  76. ** THIS FUNCTION RETURNS THE MEDIA SENSE INFORMATION
  77. **
  78. **   NEEDED PARAMETERS:          DRIVEHANDLE   : DRIVE HANDLE FOR DRIVE
  79. **
  80. **   RETURNS:                    BYTE  :  MEDIA SENSE INFORMATION
  81. **
  82. ******************************************************************************
  83. QLOGICAL_MAP                   $DLL=DDTDASD  \
  84.                                DRIVEHANDLE=NUM \
  85.                                $FUNC=@qlogical_map$qr8Kwd_List
  86. **
  87. ** THIS FUNCTION RETURNS THE LOGICAL DRIVE LETTER THAT WAS LAST USED TO
  88. ** REFERENCE (OPEN) THE DRIVE.
  89. **
  90. **   NEEDED PARAMETERS:          DRIVEHANDLE   : DRIVE HANDLE FOR DRIVE
  91. **
  92. **   RETURNS:                    BYTE  :  LOGICAL DRIVE NUMBER
  93. **
  94. ******************************************************************************
  95. SET_LOGICAL_MAP                $DLL=DDTDASD  \
  96.                                DRIVEHANDLE=NUM \
  97.                                $FUNC=@set_logical_map$qr8Kwd_List
  98. **
  99. ** THIS FUNCTION SETS THE NEXT LOGICAL DRIVE LETTER THAT IS USED TO REFERENCE
  100. ** THE DRIVE
  101. **
  102. **   NEEDED PARAMETERS:          DRIVEHANDLE   : DRIVE HANDLE FOR DRIVE
  103. **
  104. **   RETURNS:                    BYTE  :  LOGICAL DRIVE NUMBER
  105. **
  106. ******************************************************************************
  107. BLOCK_REMOVABLE                $DLL=DDTDASD  \
  108.                                DRIVEHANDLE=NUM \
  109.                                $FUNC=@block_removable$qr8Kwd_List
  110. **
  111. ** THIS FUNCTION IS USED TO DETERMINE IF THE MEDIA IS REMOVABLE OR FIXED
  112. **
  113. **   NEEDED PARAMETERS:          DRIVEHANDLE   : DRIVE HANDLE FOR DRIVE
  114. **
  115. **   RETURNS:                    BYTE  :  REMOVEABLE MEDIA (Y/N)
  116. **
  117. ******************************************************************************
  118. REDETERMINE_MEDIA              $DLL=DDTDASD  \
  119.                                DRIVEHANDLE=NUM \
  120.                                $FUNC=@redetermine_media$qr8Kwd_List
  121. **
  122. ** THIS FUNCTION REDETERMINES MEDIA.  IN THE PROCESS, IT REBUILDS THE
  123. ** DEVICE PARAMETERS.
  124. **
  125. **   NEEDED PARAMETERS:          DRIVEHANDLE   : DRIVE HANDLE FOR DRIVE
  126. **
  127. **   RETURNS:                    BYTE  :  RESERVED,  SET TO 0
  128. **
  129. ******************************************************************************
  130. READ_LOGICAL                   $DLL=DDTDASD  \
  131.                                DRIVEHANDLE=NUM  \
  132.                                HEAD=NUM  \ 
  133.                                CYLINDER=NUM  \ 
  134.                                SECTORSTART=NUM  \ 
  135.                                SECTORSIZE=NUM  \ 
  136.                                TRACKSIZE=NUM  \ 
  137.                                SECTORCOUNT=NUM  \ 
  138.                                $BUFFER=STRING  \
  139.                                $FUNC=@read_logical$qr8Kwd_List
  140. **
  141. ** THIS FUNCTION READS SECTORS FROM 1 PARTITION ON A PHYSICAL DRIVE.
  142. **
  143. **   NEEDED PARAMETERS:          DRIVEHANDLE   : DRIVE HANDLE FOR DRIVE
  144. **                               HEAD          : HEAD TO READ FROM
  145. **                               CYLINDER      : CYLINDER TO READ FROM
  146. **                               SECTORSTART   : STARTING SECTOR FOR READ
  147. **                               SECTORSIZE    : SECTOR SIZE OF DRIVE
  148. **                               TRACKSIZE     : TRACK SIZE OF DRIVE
  149. **                               SECTORCOUNT   : NUMBER OF SECTORS TO READ
  150. **                               $BUFFER       : OUTPUT BUFFER
  151. **
  152. **   RETURNS:                    $(BUFFER)
  153. **
  154. ******************************************************************************
  155. WRITE_LOGICAL                  $DLL=DDTDASD  \
  156.                                DRIVEHANDLE=NUM  \
  157.                                HEAD=NUM  \ 
  158.                                CYLINDER=NUM  \ 
  159.                                SECTORSTART=NUM  \ 
  160.                                TRACKSIZE=NUM  \ 
  161.                                $BUFFER=STRING  \
  162.                                $FUNC=@write_logical$qr8Kwd_List
  163. **
  164. ** THIS FUNCTION WRITES TO 1 PARTITION ON A PHYSICAL DRIVE.
  165. **
  166. **   NEEDED PARAMETERS:          DRIVEHANDLE   : DRIVE HANDLE FOR DRIVE
  167. **                               HEAD
  168. **                               CYLINDER
  169. **                               SECTORSTART
  170. **                               TRACKSIZE
  171. **                               $BUFFER
  172. **                               $($BUFFER)
  173. **
  174. **   RETURNS:                    NOTHING
  175. **
  176. ******************************************************************************
  177. VERIFY_LOGICAL                 $DLL=DDTDASD  \
  178.                                DRIVEHANDLE=NUM  \
  179.                                HEAD=NUM  \ 
  180.                                CYLINDER=NUM  \ 
  181.                                SECTORSTART=NUM  \ 
  182.                                TRACKSIZE=NUM  \ 
  183.                                SECTORSIZE=NUM  \ 
  184.                                SECTORCOUNT=NUM  \ 
  185.                                $FUNC=@verify_logical$qr8Kwd_List
  186. **
  187. ** THIS FUNCTION RETURNS THE STATUS OF 1 PARTITION ON A PHYSICAL DRIVE.
  188. **
  189. **   NEEDED PARAMETERS:          DRIVEHANDLE   : DRIVE HANDLE FOR DRIVE
  190. **                               HEAD
  191. **                               CYLINDER
  192. **                               SECTORSTART
  193. **                               TRACKSIZE
  194. **                               SECTORCOUNT
  195. **                               SECTORSIZE
  196. **
  197. **   RETURNS:                    add VERIFY (1/0)
  198. **
  199. ******************************************************************************
  200. FORMAT_TRACK                   $DLL=DDTDASD  \
  201.                                DRIVEHANDLE=NUM  \
  202.                                HEAD=NUM  \ 
  203.                                TRACKNUM=NUM  \ 
  204.                                SECTORSIZE=NUM  \ 
  205.                                TRACKSIZE=NUM  \ 
  206.                                $FUNC=@format_track$qr8Kwd_List
  207. **
  208. ** THIS FUNCTION FORMATS A TRACK.
  209. **
  210. **   NEEDED PARAMETERS:          DRIVEHANDLE   : DRIVE HANDLE FOR DRIVE
  211. **                               HEAD
  212. **                               TRACKNUM           
  213. **                               TRACKSIZE
  214. **                               SECTORSIZE
  215. **
  216. **   RETURNS:                    NOTHING
  217. **
  218. ******************************************************************************
  219. OPEN_PHYSICAL                  $DLL=DDTDASD  \
  220.                                DISKNUMBER=STRING  \
  221.                                $FUNC=@open_physical$qr8Kwd_List
  222. **
  223. ** THIS FUNCTION OPENS A ENTIRE PHYSICAL DISK.
  224. **
  225. **   NEEDED PARAMETERS:          DISKNUMBER   -  ex. "1:" for first fixed disk
  226. **
  227. **   RETURNS:                    add DISKHANDLE
  228. **
  229. ******************************************************************************
  230. CLOSE_PHYSICAL                 $DLL=DDTDASD  \
  231.                                DISKHANDLE=NUM  \
  232.                                $FUNC=@close_physical$qr8Kwd_List
  233. **
  234. ** THIS FUNCTION CLOSES A PHYSICAL DISK.
  235. **
  236. **   NEEDED PARAMETERS:          DISKHANDLE   : DRIVE HANDLE FOR DRIVE
  237. **
  238. **   RETURNS:                    del DISKHANDLE
  239. **
  240. ******************************************************************************
  241. LOCK_PHYSICAL                  $DLL=DDTDASD  \
  242.                                DISKHANDLE=NUM  \
  243.                                $FUNC=@lock_physical$qr8Kwd_List
  244. **
  245. ** THIS FUNCTION LOCKS A PHYSICAL DISK.
  246. **
  247. **   NEEDED PARAMETERS:          DISKHANDLE   : DRIVE HANDLE FOR DRIVE
  248. **
  249. **   RETURNS:                    NOTHING
  250. **
  251. ******************************************************************************
  252. UNLOCK_PHYSICAL                $DLL=DDTDASD  \
  253.                                DISKHANDLE=NUM  \
  254.                                $FUNC=@unlock_physical$qr8Kwd_List
  255. **
  256. ** THIS FUNCTION UNLOCKS A PHYSICAL DISK.
  257. **
  258. **   NEEDED PARAMETERS:          DISKHANDLE   : DRIVE HANDLE FOR DRIVE
  259. **
  260. **   RETURNS:                    NOTHING
  261. **
  262. ******************************************************************************
  263. GET_PHYSICAL_PARAMS            $DLL=DDTDASD  \
  264.                                DISKHANDLE=NUM  \
  265.                                $FUNC=@get_physical_params$qr8Kwd_List
  266. **
  267. ** THIS FUNCTION GETS THE PARAMATERS OF A PHYSICAL DISK.
  268. **
  269. **   NEEDED PARAMETERS:          DISKHANDLE   : DRIVE HANDLE FOR DRIVE
  270. **
  271. **   RETURNS:                    CYLINDERCOUNT
  272. **                               TRACKCOUNT
  273. **                               TRACKSIZE
  274. **
  275. ******************************************************************************
  276. WRITE_PHYSICAL                 $DLL=DDTDASD  \
  277.                                DISKHANDLE=NUM  \
  278.                                HEAD=NUM  \ 
  279.                                CYLINDER=NUM  \ 
  280.                                SECTORSTART=NUM  \ 
  281.                                SECTORSIZE=NUM  \ 
  282.                                TRACKSIZE=NUM  \ 
  283.                                $BUFFER=STRING  \
  284.                                $FUNC=@write_physical$qr8Kwd_List
  285. **
  286. ** THIS FUNCTION WRITES TO A PHYSICAL DISK.
  287. **
  288. **   NEEDED PARAMETERS:          DISKHANDLE   : DRIVE HANDLE FOR DRIVE
  289. **                               HEAD
  290. **                               CYLINDER
  291. **                               SECTORSTART
  292. **                               SECTORSIZE
  293. **                               TRACKSIZE
  294. **                               $BUFFER
  295. **                               $($BUFFER)
  296. **
  297. **   RETURNS:                    NOTHING
  298. **
  299. ******************************************************************************
  300. READ_PHYSICAL                  $DLL=DDTDASD  \
  301.                                DISKHANDLE=NUM  \
  302.                                HEAD=NUM  \ 
  303.                                CYLINDER=NUM  \ 
  304.                                SECTORSTART=NUM  \ 
  305.                                SECTORCOUNT=NUM  \ 
  306.                                SECTORSIZE=NUM  \ 
  307.                                TRACKSIZE=NUM  \ 
  308.                                $BUFFER=STRING  \
  309.                                $FUNC=@read_physical$qr8Kwd_List
  310. **
  311. ** THIS FUNCTION READS SECTORS FROM A PHYSICAL DISK.
  312. **
  313. **   NEEDED PARAMETERS:          DISKHANDLE   : DRIVE HANDLE FOR DRIVE
  314. **                               HEAD
  315. **                               CYLINDER
  316. **                               SECTORSTART
  317. **                               SECTORCOUNT
  318. **                               SECTORSIZE
  319. **                               TRACKSIZE
  320. **                               $BUFFER
  321. **
  322. **   RETURNS:                    add $($BUFFER)
  323. **
  324. ******************************************************************************
  325. VERIFY_PHYSICAL                $DLL=DDTDASD  \
  326.                                DISKHANDLE=NUM  \
  327.                                HEAD=NUM  \ 
  328.                                CYLINDER=NUM  \ 
  329.                                SECTORSTART=NUM  \ 
  330.                                SECTORCOUNT=NUM  \ 
  331.                                SECTORSIZE=NUM  \ 
  332.                                TRACKSIZE=NUM  \ 
  333.                                $FUNC=@verify_physical$qr8Kwd_List
  334. **
  335. ** THIS FUNCTION RETURNS THE STATUS OF A PHYSICAL DISK.
  336. **
  337. **   NEEDED PARAMETERS:          DISKHANDLE   : DRIVE HANDLE FOR DRIVE
  338. **                               HEAD
  339. **                               CYLINDER
  340. **                               SECTORSTART
  341. **                               SECTORCOUNT
  342. **                               SECTORSIZE
  343. **                               TRACKSIZE
  344. **
  345. **   RETURNS:                    add VERIFY (1/0)
  346. **
  347. ******************************************************************************
  348. READ_FILE                      $DLL=DDTDASD  \
  349.                                DISKHANDLE=NUM  \
  350.                                FILENAME=STRING  \
  351.                                BYTESTART=NUM  \                                                                 
  352.                                BYTECOUNT=NUM  \                                                                 
  353.                                $BUFFER=STRING  \
  354.                                $FUNC=@read_file$qr8Kwd_List
  355. **
  356. ** THIS FUNCTION READS A FILE FROM A PHYSICAL DISK.
  357. **
  358. **   NEEDED PARAMETERS:          DISKHANDLE   : DRIVE HANDLE FOR DRIVE
  359. **                               FILENAME
  360. **                               BYTESTART
  361. **                               BYTECOUNT
  362. **                               $BUFFER
  363. **
  364. **   RETURNS:                    add $($BUFFER)
  365. **
  366. ******************************************************************************
  367. WRITE_FILE                     $DLL=DDTDASD  \
  368.                                DISKHANDLE=NUM  \
  369.                                FILENAME=STRING  \
  370.                                BYTESTART=NUM  \                                                                 
  371.                                $BUFFER=STRING  \
  372.                                $FUNC=@write_file$qr8Kwd_List
  373. **
  374. ** THIS FUNCTION WRITES A FILE TO A PHYSICAL DISK.
  375. **
  376. **   NEEDED PARAMETERS:          DISKHANDLE   : DRIVE HANDLE FOR DRIVE
  377. **                               FILENAME
  378. **                               BYTESTART
  379. **                               $BUFFER
  380. **                               $(BUFFER)
  381. **
  382. **   RETURNS:                    NOTHING
  383. **
  384. ******************************************************************************
  385. SET_DEVICEPARAMS                $DLL=DDTDASD  \
  386.                                 $FUNC=@set_deviceparams$qr8Kwd_List \
  387.                                 SECTORSIZE=NUM \
  388.                                 CLUSTERSIZE=NUM \
  389.                                 FATCOUNT=NUM \
  390.                                 ROOTCOUNT=NUM \
  391.                                 TOTALSECTORS=NUM \
  392.                                 FATSIZE=NUM \           
  393.                                 TRACKSIZE=NUM \         
  394.                                 HEADCOUNT=NUM \
  395.                                 TOTALSECTORS=NUM \
  396.                                 CYLINDERS=NUM \
  397.                                 DEVICETYPE=NUM 
  398.